/**
 * 表单验证工具类
 * 提供通用的验证器和验证方法
 */

// 通用验证正则表达式
export const PATTERNS = {
  // 中文姓名
  chineseName: /^[\u4e00-\u9fa5]{2,10}$/,
  // 手机号
  mobile: /^1[3-9]\d{9}$/,
  // 邮箱
  email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
  // 身份证号
  idCard: /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/,
  // 编号格式（字母数字组合）
  code: /^[A-Za-z0-9]{3,20}$/,
  // 产品名称（中文、英文、数字、空格、横线）
  productName: /^[\u4e00-\u9fa5a-zA-Z0-9\s\-]{2,50}$/,
  // 数字（支持小数）
  number: /^\d+(\.\d+)?$/,
  // 整数
  integer: /^\d+$/,
  // 正整数
  positiveInteger: /^[1-9]\d*$/
};

// 通用验证器
export const validators = {
  /**
   * 必填验证器
   */
  required: (message = '此项为必填项') => {
    return { required: true, message, trigger: 'blur' };
  },

  /**
   * 字符串长度验证器
   */
  length: (min, max, message) => {
    const defaultMessage = `长度应在${min}到${max}个字符之间`;
    return { min, max, message: message || defaultMessage, trigger: 'blur' };
  },

  /**
   * 数字范围验证器
   */
  numberRange: (min, max, message) => {
    const defaultMessage = `数值应在${min}到${max}之间`;
    return { type: 'number', min, max, message: message || defaultMessage, trigger: 'blur' };
  },

  /**
   * 正则表达式验证器
   */
  pattern: (pattern, message) => {
    return { pattern, message, trigger: 'blur' };
  },

  /**
   * 自定义验证器
   */
  custom: (validator, message = '验证失败') => {
    return { validator, message, trigger: 'blur' };
  },

  /**
   * 邮箱验证器
   */
  email: (message = '请输入正确的邮箱地址') => {
    return validators.pattern(PATTERNS.email, message);
  },

  /**
   * 手机号验证器
   */
  mobile: (message = '请输入正确的手机号') => {
    return validators.pattern(PATTERNS.mobile, message);
  },

  /**
   * 身份证验证器
   */
  idCard: (message = '请输入正确的身份证号') => {
    return validators.pattern(PATTERNS.idCard, message);
  },

  /**
   * 中文姓名验证器
   */
  chineseName: (message = '请输入正确的中文姓名') => {
    return validators.pattern(PATTERNS.chineseName, message);
  },

  /**
   * 编号验证器
   */
  code: (message = '编号只能包含字母和数字，长度3-20位') => {
    return validators.pattern(PATTERNS.code, message);
  },

  /**
   * 产品名称验证器
   */
  productName: (message = '产品名称格式不正确') => {
    return validators.pattern(PATTERNS.productName, message);
  }
};

// 自定义验证函数
export const customValidators = {
  /**
   * 验证日期不能早于今天
   */
  notBeforeToday: (rule, value, callback) => {
    if (!value) {
      callback();
      return;
    }
    
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const inputDate = new Date(value);
    
    if (inputDate < today) {
      callback(new Error('日期不能早于今天'));
    } else {
      callback();
    }
  },

  /**
   * 验证日期不能超过指定天数
   */
  notAfterDays: (days) => {
    return (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      const today = new Date();
      const maxDate = new Date(today);
      maxDate.setDate(maxDate.getDate() + days);
      const inputDate = new Date(value);
      
      if (inputDate > maxDate) {
        callback(new Error(`日期不能超过${days}天后`));
      } else {
        callback();
      }
    };
  },

  /**
   * 验证数字精度
   */
  decimal: (precision) => {
    return (rule, value, callback) => {
      if (value === null || value === undefined || value === '') {
        callback();
        return;
      }
      
      const str = value.toString();
      const decimalIndex = str.indexOf('.');
      
      if (decimalIndex !== -1) {
        const decimalPlaces = str.length - decimalIndex - 1;
        if (decimalPlaces > precision) {
          callback(new Error(`小数位数不能超过${precision}位`));
          return;
        }
      }
      
      callback();
    };
  },

  /**
   * 验证选项是否存在于选项列表中
   */
  inOptions: (options, valueKey = 'value', message = '选择的选项不存在') => {
    return (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      const exists = options.some(option => option[valueKey] === value);
      if (!exists) {
        callback(new Error(message));
      } else {
        callback();
      }
    };
  },

  /**
   * 验证依赖字段
   */
  dependsOn: (dependField, dependValue, message = '请先选择依赖项') => {
    return (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      // 这里需要通过某种方式获取到表单数据
      // 实际使用时需要传入表单引用
      callback();
    };
  },

  /**
   * 验证唯一性（需要配合API调用）
   */
  unique: (checkApi, excludeId = null, message = '该值已存在') => {
    return async (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      try {
        const response = await checkApi(value, excludeId);
        if (!response.unique) {
          callback(new Error(message));
        } else {
          callback();
        }
      } catch (error) {
        // API调用失败时不阻止表单提交
        console.warn('唯一性验证失败:', error);
        callback();
      }
    };
  }
};

// 质量管理系统专用验证器
export const qmsValidators = {
  /**
   * 验证产品状态
   */
  productStatus: (productOptions) => {
    return (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      const product = productOptions.value?.find(item => item.id === value);
      if (!product) {
        callback(new Error('选择的产品不存在'));
        return;
      }
      
      if (product.status === '0') {
        callback(new Error('选择的产品已停用'));
        return;
      }
      
      callback();
    };
  },

  /**
   * 验证批次与产品的关联
   */
  batchProductMatch: (form, batchOptions) => {
    return (rule, value, callback) => {
      if (!value || !form.productId) {
        callback();
        return;
      }
      
      const batch = batchOptions.value?.find(item => item.id === value);
      if (!batch) {
        callback(new Error('选择的批次不存在'));
        return;
      }
      
      if (batch.productId !== form.productId) {
        callback(new Error('选择的批次与产品不匹配'));
        return;
      }
      
      if (batch.status === '已完成') {
        callback(new Error('选择的批次已完成'));
        return;
      }
      
      callback();
    };
  },

  /**
   * 验证抽样数量不超过批次数量
   */
  sampleQuantityLimit: (form, batchOptions) => {
    return (rule, value, callback) => {
      if (!value || !form.batchId) {
        callback();
        return;
      }
      
      const batch = batchOptions.value?.find(item => item.id === form.batchId);
      if (batch && batch.quantity && value > batch.quantity) {
        callback(new Error(`抽样数量不能超过批次数量(${batch.quantity})`));
        return;
      }
      
      callback();
    };
  },

  /**
   * 验证检验类型格式
   */
  inspectionType: (message = '检验类型只能包含中文、英文、数字和空格') => {
    return validators.pattern(PATTERNS.productName, message);
  },

  /**
   * 验证检验人员状态
   */
  inspectorStatus: (userOptions) => {
    return (rule, value, callback) => {
      if (!value) {
        callback();
        return;
      }
      
      const inspector = userOptions.value?.find(item => item.nickName === value);
      if (!inspector) {
        callback(new Error('选择的检验人员不存在'));
        return;
      }
      
      if (inspector.status === '1') {
        callback(new Error('选择的检验人员已停用'));
        return;
      }
      
      callback();
    };
  }
};

// 表单验证工具函数
export const formUtils = {
  /**
   * 创建验证规则集合
   */
  createRules: (rulesConfig) => {
    const rules = {};
    
    for (const [field, config] of Object.entries(rulesConfig)) {
      rules[field] = Array.isArray(config) ? config : [config];
    }
    
    return rules;
  },

  /**
   * 合并验证规则
   */
  mergeRules: (...rulesSets) => {
    const merged = {};
    
    rulesSets.forEach(rules => {
      for (const [field, fieldRules] of Object.entries(rules)) {
        if (!merged[field]) {
          merged[field] = [];
        }
        merged[field] = merged[field].concat(fieldRules);
      }
    });
    
    return merged;
  },

  /**
   * 验证表单
   */
  validateForm: (formRef, callback) => {
    if (!formRef) {
      console.error('表单引用不存在');
      return;
    }
    
    formRef.validate((valid, fields) => {
      if (callback) {
        callback(valid, fields);
      }
    });
  },

  /**
   * 重置表单验证状态
   */
  resetValidation: (formRef, fields = null) => {
    if (!formRef) return;
    
    if (fields) {
      formRef.clearValidate(fields);
    } else {
      formRef.resetFields();
    }
  }
};

// 导出默认配置
export default {
  validators,
  customValidators,
  qmsValidators,
  formUtils,
  PATTERNS
}; 